package com.koron.css2.newProjectCenter.function.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.koron.css2.ServerInterface;
import com.koron.css2.newProjectCenter.function.base.DictAction;
import com.koron.css2.newProjectCenter.function.bean.Dictionary;
import com.koron.css2.newProjectCenter.function.bean.DictionaryDetail;
import com.koron.css2.newProjectCenter.function.mapper.DictionaryMapper;
import com.koron.css2.serviceManage.bean.RequestBean;
import com.koron.css2.serviceManage.bean.UserInfoBean;
import com.koron.util.Constant;
import com.koron.util.Tools;
import org.apache.commons.lang3.StringUtils;
import org.koron.ebs.mybatis.EnvSource;
import org.koron.ebs.mybatis.SessionFactory;
import org.swan.bean.MessageBean;

import java.util.List;

@SuppressWarnings("rawtypes")
public class DictionaryController implements ServerInterface {
    /**
     * 执行不同的操作基于用户请求
     *
     * @param factory  会话工厂，用于创建新的会话
     * @param userInfo 用户信息，包含用户相关数据
     * @param req      请求信息，包括用户请求的操作数据
     * @return MessageBean<?> 返回操作结果的消息豆
     */
    @Override
    public MessageBean<?> exec(SessionFactory factory, UserInfoBean userInfo, RequestBean req) {
        // 将请求数据转换为Action对象
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            DictAction dictAction = objectMapper.readValue(objectMapper.writeValueAsString(req.getData()), DictAction.class);
            DictionaryMapper mapper = factory.getMapper(DictionaryMapper.class, EnvSource.DEFAULT);

            // 根据Action中的to do字段决定执行的操作
            switch (dictAction.getToDo()) {
                case 0:
                    // 新增字典或添加字典选项
                    // 设置创建者账号和名称
                    dictAction.setCreateAccount(userInfo.getUserInfo().getAcount());
                    dictAction.setCreateName(userInfo.getUserInfo().getName());
                    // 检查字典ID是否为空，如果为空，则调用添加字典方法，否则调用添加字典详情方法
                    if (StringUtils.isBlank(dictAction.getDictId()))
                        return addDictionary(mapper, dictAction);
                    return addDictionaryDetail(mapper, dictAction);
                case 1:
                    // 获取字典列表
                    return getDictionaryList(mapper, dictAction);
                case 2:
                    // 删除字典或删除字典选项
                    if (StringUtils.isBlank(dictAction.getDictId()))
                        return MessageBean.create(Constant.MESSAGE_INT_FAIL, "参数错误", null);
                    if (!mapper.dictIdIsExist(dictAction.getDictId())) {
                        return MessageBean.create(Constant.MESSAGE_INT_FAIL, "字典id不存在", null);
                    }
                    return deleteDictionary(mapper, userInfo, dictAction.getDictId(), dictAction.getDetailId());
                case 3:
                    // 修改字典或修改字典选项
                    if (StringUtils.isBlank(dictAction.getDictId()))
                        return MessageBean.create(Constant.MESSAGE_INT_FAIL, "参数错误", null);
                    if (!mapper.dictIdIsExist(dictAction.getDictId())) {
                        return MessageBean.create(Constant.MESSAGE_INT_FAIL, "字典id不存在", null);
                    }
                    return updateDictionary(mapper, userInfo, dictAction);
                case 4:
                    // 获取字典选项
                    return getDetailListByDictId(mapper, dictAction.getDictId());
                default:
                    // 如果操作不合法，返回错误消息
                    return MessageBean.create(Constant.MESSAGE_INT_FAIL, "非法操作", null);
            }
        } catch (Exception e) {
            logger.error("未知错误", e);
            return MessageBean.create(Constant.ILLEGAL_PARAMETER, "未知错误", null);
        }
    }

    private MessageBean<?> addDictionaryDetail(DictionaryMapper mapper, DictAction dictAction) {
        if (!mapper.dictIdIsExist(dictAction.getDictId()))
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "父级配置编码不存在", null);
        dictAction.setDetailId(Tools.getObjectId());
        if (StringUtils.isBlank(dictAction.getDetailName()) || dictAction.getDetailValue() == null)
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "参数错误", null);
        if (mapper.dictDetailValueIsExist(dictAction.getDictId(), dictAction.getDetailValue())) {
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "配置值已存在", null);
        }
        mapper.insertDictDetail(dictAction);
        return MessageBean.create(Constant.MESSAGE_INT_SUCCESS, "新增成功", null);
    }

    private MessageBean<?> addDictionary(DictionaryMapper mapper, DictAction dictAction) {
        if (StringUtils.isBlank(dictAction.getDictName()) || StringUtils.isBlank(dictAction.getDictCode()))
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "参数错误", null);
        // 首先判断字典code是否存在，如存在则提示重复
        if (mapper.dictCodeIsExist(dictAction.getDictCode())) {
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "配置编码已存在", null);
        }
        // 开始新增
        dictAction.setDictId(Tools.getObjectId());
        mapper.insertDict(dictAction);
        return MessageBean.create(Constant.MESSAGE_INT_SUCCESS, "新增成功", null);
    }

    /**
     * 更新字典信息
     * 根据传入的Action对象中的字典ID和详细ID，决定是更新字典基本信息还是详细信息
     *
     * @param mapper   字典数据访问对象，用于执行数据库操作
     * @param userInfo 用户信息对象，未在方法体内使用，可能用于权限校验或日志记录
     * @param dictAction   包含更新操作所需信息的对象，包括字典ID、详细ID、字典名称等
     * @return 返回一个消息对象，表示更新操作的结果
     */
    private MessageBean<?> updateDictionary(DictionaryMapper mapper, UserInfoBean userInfo, DictAction dictAction) {
        // 判断详细ID是否为空，以决定更新字典基本信息还是详细信息
        if (StringUtils.isBlank(dictAction.getDetailId())) {
            // 如果详细ID为空，则更新字典的基本信息，包括字典名称和备注
            mapper.updateDictByDictId(dictAction.getDictId(), dictAction.getDictName(), dictAction.getRemark());
        } else {
            // 如果详细ID不为空，则更新字典的详细信息，包括详细名称和详细值
            if (mapper.dictDetailValueIsExist(dictAction.getDictId(), dictAction.getDetailValue())) {
                return MessageBean.create(Constant.MESSAGE_INT_FAIL, "配置值已存在", null);
            }
            mapper.updateDictDetailByDictIdAndDetailId(dictAction.getDictId(), dictAction.getDetailId(), dictAction.getDetailName(), dictAction.getDetailValue());
        }
        // 返回成功消息，表示更新操作完成
        return MessageBean.create(Constant.MESSAGE_INT_SUCCESS, "修改成功", null);
    }

    /**
     * 根据字典ID获取字典详细列表
     *
     * @param mapper 数据库映射接口，用于执行数据库查询
     * @param id     字典ID，用于查询字典详细信息的唯一标识
     * @return 返回一个MessageBean对象，包含查询结果或错误信息
     */
    private MessageBean<?> getDetailListByDictId(DictionaryMapper mapper, String id) {
        // 判断id是否存在
        if (StringUtils.isBlank(id)) {
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "字典id不能为空", null);
        }
        // 验证字典ID是否在数据库中存在
        if (!mapper.dictIdIsExist(id)) {
            return MessageBean.create(Constant.MESSAGE_INT_FAIL, "字典id不存在", null);
        }
        // 查询字典详细信息列表
        List<DictionaryDetail> list = mapper.getDetailListByDictId(id);
        // 创建一个成功消息对象，用于返回查询结果
        MessageBean<List> info = MessageBean.create(Constant.MESSAGE_INT_SUCCESS, "查询成功", List.class);
        info.setData(list);
        return info;
    }

    /**
     * 获取字典列表信息
     * 该方法用于处理字典数据的分页查询逻辑，确保用户获取的数据是分页且有效的
     *
     * @param mapper 数据字典映射器，用于执行数据库查询操作
     * @param dictAction 动作参数，包含分页查询所需的页码和每页记录数等信息
     * @return 返回一个MessageBean对象，包含查询结果和分页信息
     */
    private MessageBean<?> getDictionaryList(DictionaryMapper mapper, DictAction dictAction) {
        // 校验并设置页码，确保其大于0
        if (dictAction.getPage() <= 0)
            dictAction.setPage(1);
        // 校验并设置每页记录数，确保其大于0
        if (dictAction.getPageCount() <= 0)
            dictAction.setPageCount(10);

        // 启用MyBatis分页插件，根据action中的页码和记录数进行分页
        PageHelper.startPage(dictAction.getPage(), dictAction.getPageCount());
        // 执行数据库查询，获取分页后的字典列表
        List<Dictionary> list = mapper.findDictionaryListByPage(dictAction);

        // 用于封装查询结果和分页信息
        MessageBean<PageInfo> info = MessageBean.create(Constant.MESSAGE_INT_SUCCESS, "查询成功", PageInfo.class);
        // 设置消息的数据为分页信息对象，封装查询到的字典列表
        info.setData(new PageInfo<>(list));
        // 返回封装好的消息
        return info;
    }

    /**
     * 根据字典id批量删除字典信息
     * 如果删除的是字典，则删除字典下的所有字典明细，此时需要传递：dictId -> 字典id
     * 如果删除的是字典明细，则仅删除字典明细，此时需要传递：dictId -> 字典id、detailId -> 字典明细id
     */
    private MessageBean<?> deleteDictionary(DictionaryMapper mapper, UserInfoBean userInfo, String dictId, String detailId) {
        if (StringUtils.isBlank(detailId)) {
            // 删除对应的字典详情信息
            mapper.deleteDictDetailByDictId(dictId);
            // 删除对应的字典信息
            mapper.deleteDictByDictId(dictId);
        } else {
            // 根据字典id和字典详情id删除字典明细信息
            mapper.deleteDictDetailByDictIdAndDetailId(dictId, detailId);
        }
        return MessageBean.create(Constant.MESSAGE_INT_SUCCESS, "删除成功", null);
    }
}
